// pages/audio/audio.js
const gaiaManager = require('../../utils/gaiaManager.js').gaiaManager
const bluetoothManager = require('../../utils/bluetooth.js').bluetoothManager
const audioManager = require('../../utils/audioManager.js')

Page({
  data: {
    // 页面状态
    isLoading: true,
    showError: false,
    errorMessage: '',
    
    // 设备状态
    deviceConnected: false,
    eqEnabled: false,
    
    // EQ预设
    presets: [
      { type: 'USER', value: 63, name: 'USER' }, // USER 预设放在第一位
      { type: 'OFF', value: 0, name: 'FLAT' },
      { type: 'PRE_SET', value: 1, name: 'ROCK' },
      { type: 'PRE_SET', value: 2, name: 'POP' },
      { type: 'PRE_SET', value: 3, name: 'CLASSICAL' },
      { type: 'PRE_SET', value: 8, name: 'FUNK' },
      { type: 'PRE_SET', value: 9, name: 'SPEECH' }
    ],
    selectedPreset: null,
    presetRow1: [],
    presetRow2: [],
    presetRow3: [],
    presetRow4: [],
    
    // 自定义EQ
    isCustomMode: false,
    eqBands: [],
    userBands: [],
    
    // 横向EQ频段数据
    horizontalEqBands: [],
    
    // 动态计算的滑块区域高度
    sliderAreaHeight: '350px',
    
    // DB范围（与Android保持一致，固定范围）
    dbRange: {
      min: -12,
      midMin: -6,
      midMax: 3,
      max: 3
    },
    
    // 横向滑块状态
    activeHorizontalSliderIndex: null,
    isHorizontalSliderDragging: false,
    
    // 标志：是否正在执行横向EQ调整
    isAdjustingHorizontalEQ: true,
    
    // 图表相关
    graphContext: null,
    canvasWidth: 0,
    canvasHeight: 0,
    showGraph: false,
    
    // Vant Slider 数据（音量默认 0 => 最下方）
    volumeValue: 0,
    bassValue: 0,
    trebleValue: 0,
    balanceValue: 0,
  },

  onLoad(options) {
    this.initPage()
    this.setupConnectionListener()
  },

  onShow() {
    // 初始化音频管理器
    audioManager.init(gaiaManager)
    audioManager.setConnected(gaiaManager.isConnected)
    
    // 设置gaiaManager的音频管理器引用
    gaiaManager.setAudioManager(audioManager)
    
    // 设置音频页面的命令响应回调
    audioManager.setOnCommandResponse((commandId, payload, type, vendorId) => {
      console.log('🎵 [音频页面] 收到音频命令响应:', { 
        commandId: `0x${commandId.toString(16).padStart(2, '0')}`, 
        payloadLength: payload.length,
        type,
        vendorId: `0x${vendorId.toString(16).padStart(4, '0')}`
      })
      
      // 处理音频相关的命令响应
      switch (commandId) {
        case 0x02: // V1_GET_EQ_SET - 获取当前预设
          // 检查是否正在执行横向EQ调整，如果是则不处理预设状态响应
          if (this.data.isAdjustingHorizontalEQ) {
            this.handleSelectedPresetResponse(payload)
          }
          break
        case 0x03: // V1_SET_EQ_SET - 设置预设
          console.log('🎵 [音频页面] 预设设置响应')
          break
        case 0x05: // V1_GET_USER_SET_CONFIGURATION - 获取用户EQ配置
          console.log('🎵 [音频页面] 用户EQ配置响应')
          this.handleUserSetConfigurationResponse(payload)
          break
        case 0x06: // V1_SET_USER_SET_CONFIGURATION - 频段增益设置响应
          console.log('🎵 [音频页面] 频段增益设置响应 - 已拦截，不处理预设状态')
          // 拦截此响应，防止被误认为是预设状态响应
          // 频段增益设置不需要更新预设状态
          break
        case 0x00: // V1_GET_EQ_STATE
          console.log('🎵 [音频页面] EQ状态响应')
          break
        // 其他音频相关命令...
      }
    })

    // 设置音频页面的BLE数据回调（用于调试和原始数据处理）
    audioManager.setBleDataCallback((data) => {
      console.log('🎵 [音频页面] 收到BLE原始数据:', data)
      this.handleBleData(data)
    })
    
    // 页面显示时检查连接状态并加载数据
    this.checkConnectionStatus().then((isConnected) => {
      if (isConnected) {
        this.loadEQData()
        // 初始化Vant Slider数据
        this.initVantSliderData()
      } else {
        // 即使设备未连接，也尝试绘制默认图表
        this.drawDefaultChart()
        // 初始化Vant Slider数据（使用默认值）
        this.initVantSliderData()
      }
    })
  },

  onHide() {
    // 清除音频页面的回调，让其他页面可以设置回调
    audioManager.setOnCommandResponse(null)
    audioManager.setBleDataCallback(null)
    this.removeConnectionListener()
  },

  onReady() {
   
  },

  // 页面显示时重新绘制图表
  onPageShow() {
    // 延迟检查Canvas初始化状态
    setTimeout(() => {
      this.ensureCanvasInitialized()
      // 重新计算滑块区域高度
      this.calculateSliderAreaHeight()
    }, 500)
    
    // 再次延迟确保数据加载完成
    setTimeout(() => {
      if (this.data.eqBands && this.data.eqBands.length > 0) {
        this.forceCanvasInit()
      }
    }, 1000)
  },
  getInitCanvas(){
    console.log('🎵 [音频页面] 开始初始化Canvas')
    
    // 延迟初始化Canvas，确保页面完全渲染
    setTimeout(() => {
      this.initCanvasWithRetry(0)
    }, 100)
  },

  // 带重试机制的Canvas初始化
  initCanvasWithRetry(retryCount = 0) {
    const maxRetries = 3
    
    try {
      console.log(`🎵 [音频页面] Canvas初始化尝试 ${retryCount + 1}/${maxRetries + 1}`)
      console.log('🎵 [音频页面] 当前isCustomMode状态:', this.data.isCustomMode)
      
      // 首先确保isCustomMode为true，让Canvas元素渲染
      if (!this.data.isCustomMode) {
        console.log('🎵 [音频页面] 设置isCustomMode为true，确保Canvas元素渲染')
        this.setData({ isCustomMode: true })
        
        // 等待DOM更新
        setTimeout(() => {
          this.initCanvasWithRetry(retryCount)
        }, 100)
        return
      }
      
      const query = wx.createSelectorQuery()
      query.select('.eq-graph')
        .fields({ node: true, size: true })
        .exec((res) => {
          console.log('🎵 [音频页面] Canvas查询结果:', res)
          
          if (res[0] && res[0].node) {
            // 新版Canvas API
            console.log('🎵 [音频页面] 使用新版Canvas API')
            const canvas = res[0].node
            const ctx = canvas.getContext('2d')
            const dpr = wx.getSystemInfoSync().pixelRatio
            canvas.width = res[0].width * dpr
            canvas.height = res[0].height * dpr
            ctx.scale(dpr, dpr)
            
            this.setData({
              graphContext: ctx,
              canvasWidth: res[0].width,
              canvasHeight: res[0].height
            })
            
            console.log('🎵 [音频页面] Canvas初始化成功')
            
            // 等待Canvas初始化完成后再绘制
            setTimeout(() => {
              this.drawChartAfterInit()
            }, 100)
            
          } else if (res[0] && res[0].width && res[0].height) {
            // 旧版Canvas API
            console.log('🎵 [音频页面] 使用旧版Canvas API')
            this.initCanvasLegacy()
            
            setTimeout(() => {
              this.drawChartAfterInit()
            }, 100)
            
          } else {
            console.warn(`🎵 [音频页面] Canvas元素未找到，res=${JSON.stringify(res)}，重试 ${retryCount + 1}/${maxRetries + 1}`)
            
            if (retryCount < maxRetries) {
              // 重试
              setTimeout(() => {
                this.initCanvasWithRetry(retryCount + 1)
              }, 500)
            } else {
              console.error('🎵 [音频页面] Canvas初始化最终失败，跳过图表绘制')
              // 动态计算滑块区域高度
              this.calculateSliderAreaHeight()
            }
          }
        })
        
    } catch (error) {
      console.error('🎵 [音频页面] Canvas初始化异常:', error)
      
      if (retryCount < maxRetries) {
        setTimeout(() => {
          this.initCanvasWithRetry(retryCount + 1)
        }, 500)
      } else {
        console.error('🎵 [音频页面] Canvas初始化最终失败')
        this.calculateSliderAreaHeight()
      }
    }
  },

  // Canvas初始化后绘制图表
  drawChartAfterInit() {
    try {
      // 如果还没有数据，绘制默认图表
      if (!this.data.eqBands || this.data.eqBands.length === 0) {
        console.log('🎵 [音频页面] 绘制默认图表')
        this.drawDefaultChart()
      } else {
        console.log('🎵 [音频页面] 绘制EQ图表')
        this.drawEQGraph()
      }
      
      // 动态计算滑块区域高度
      this.calculateSliderAreaHeight()
      
    } catch (error) {
      console.error('🎵 [音频页面] 绘制图表失败:', error)
    }
  },
  // 初始化页面
  initPage() {
    // 初始化横向EQ频段模拟数据
    const horizontalEqBands = this.initHorizontalEqBands()
    
    this.setData({
      isLoading: true,
      showError: false,
      errorMessage: '',
      horizontalEqBands
    })
  },

  // 初始化横向EQ频段模拟数据
  initHorizontalEqBands() {
    // 横向EQ频段频率数据（对应Y轴k数据）
    // 注意：这里使用默认频率，实际使用时应该从设备获取动态频率
    const horizontalFrequencies = [20000, 10000, 5000, 2000, 1000, 500, 200, 100, 50, 20]
    
    return horizontalFrequencies.map((freq, index) => ({
      index: index,
      frequency: this.formatHorizontalFrequency(freq),
      gain: 0, // 实际增益
      displayGain: (-9 - 0), // 垂直显示使用的反转增益
      filter: 'PARAMETRIC_EQUALIZER',
      enabled: true,
      visible: true
    })).reverse() // 倒序展示
  },

  // 更新横向EQ频段数据（从设备获取的动态数据）
  updateHorizontalEqBands(userBands) {
    if (!userBands || userBands.length === 0) {
      console.warn('🎵 [横向EQ] 用户频段数据为空，使用默认数据')
      return
    }

    // 将用户频段数据转换为横向EQ格式
    // 注意：横向EQ的频率顺序是反的（从高频到低频）
    const horizontalEqBands = []
    const bandCount = userBands.length
    
    for (let i = 0; i < bandCount; i++) {
      const userBand = userBands[i]
      const horizontalIndex = bandCount - 1 - i // 反转索引
      
      horizontalEqBands[horizontalIndex] = {
        index: horizontalIndex,
        frequency: this.formatHorizontalFrequency(userBand.frequency),
        gain: userBand.gain || 0,
        // 垂直显示数值（顶部为3，底部为-12）：display = -9 - gain
        displayGain: -9 - (userBand.gain || 0),
        filter: userBand.filter || 'PARAMETRIC_EQUALIZER',
        enabled: true,
        visible: true,
        q: userBand.q || 0.7,
        id: userBand.id || horizontalIndex
      }
    }
    
    // 倒序展示
    const reversedBands = horizontalEqBands.reverse()
    
    console.log('🎵 [横向EQ] 更新横向EQ频段数据（倒序）:', reversedBands)
    this.setData({ horizontalEqBands: reversedBands })
  },

  // 格式化横向EQ频率显示
  formatHorizontalFrequency(freq) {
    if (freq >= 1000) {
      return `${(freq / 1000).toFixed(0)}k`
    } else {
      return `${freq}`
    }
  },

  // 横向滑块值改变事件处理 - 与主要EQ控制区域保持一致的事件效果
  async onHorizontalSliderChange(e) {
    if(this.data.isAdjustingHorizontalEQ){
      this.setData({ isAdjustingHorizontalEQ: false })
    }
    const { band } = e.currentTarget.dataset
    const rawValue = typeof e.detail === 'object' ? e.detail.value : e.detail
    // 垂直方向数值反转：顶部应为 3，底部为 -12
    // 滑块值范围：0-15，需要转换为 -12 到 3
    // 转换公式：value = 3 - rawValue
    const invertedValue = (-12 + 3) - rawValue // 等于 -9 
    const value = invertedValue
    if (band === undefined) return
    
    // 状态验证：确保当前处于USER模式才能调整频段增益
    if (this.data.selectedPreset !== 63) {
      console.warn('🎵 [横向EQ] 当前不是USER模式，无法调整频段增益')
      wx.showToast({
        title: '请先选择USER模式',
        icon: 'none'
      })
      return
    }
    
    // 设置标志：正在执行横向EQ调整
    
    try {
      console.log('🎵 [横向EQ] 滑块变化，频段:', band, '原始值:', rawValue, '增益:', value)
      
      // 立即更新本地数据，让图表实时响应
      const horizontalEqBands = [...this.data.horizontalEqBands]
      horizontalEqBands[band].gain = value
      horizontalEqBands[band].displayGain = rawValue
      this.setData({ horizontalEqBands })
      
      // 同步更新主要EQ控制区域的数据
      this.syncHorizontalToMainEQ(band, value)
      
      // 立即重绘图表，让曲线跟着变化
      this.drawEQGraph()
    
      // 调用gaiaManager设置频段增益，这会发送GAIA命令到设备
      try {
        console.log('🎵 [横向EQ] 设置频段增益发送:', { bandIndex: band, gain: value })
        
        const result = await gaiaManager.setUserBandGain(band, value)
        
        if (result && result.success) {
          console.log(`🎵 [横向EQ] 频段${band}增益设置为${value}dB成功`)
        } else {
          wx.showToast({
            title: '设置频段增益失败',
            icon: 'error'
          })
        }
      } catch (error) {
        console.error('🎵 [横向EQ] 设置频段增益失败:', error)
        wx.showToast({
          title: '设置频段增益失败',
          icon: 'error'
        })
      }
    } catch (error) {
      console.error('🎵 [横向EQ] 设置EQ失败:', error)
      wx.showToast({
        title: '设置EQ失败',
        icon: 'error'
      })
    } finally {
      // 清理标志：横向EQ调整完成
      this.setData({ isAdjustingHorizontalEQ: false })
    }
  },

  // 横向滑块触摸开始 - 与主要EQ控制区域保持一致
  onHorizontalSliderTouchStart(e) {
    const bandIndex = parseInt(e.currentTarget.dataset.band)
    console.log('🎵 [横向EQ] 滑块触摸开始，频段索引:', bandIndex)
    this.setData({
      activeHorizontalSliderIndex: bandIndex,
      isHorizontalSliderDragging: true
    })
    
    // 立即处理触摸位置
    this.handleHorizontalSliderTouch(e, bandIndex)
  },

  // 横向滑块触摸移动 - 与主要EQ控制区域保持一致
  onHorizontalSliderTouchMove(e) {
    if (!this.data.isHorizontalSliderDragging) return
    
    const bandIndex = parseInt(e.currentTarget.dataset.band)
    this.handleHorizontalSliderTouch(e, bandIndex)
  },

  // 横向滑块触摸结束 - 与主要EQ控制区域保持一致
  async onHorizontalSliderTouchEnd(e) {
    // 先保存当前活动的滑块索引，然后再清除状态
    const { activeHorizontalSliderIndex } = this.data
    console.log('🎵 [横向EQ] 滑动结束，当前活动滑块索引:', activeHorizontalSliderIndex)
    
    // 清除滑动状态
    this.setData({
      isHorizontalSliderDragging: false,
      activeHorizontalSliderIndex: null
    })
    
    // 参考安卓版本逻辑：滑动结束后发送频段增益命令
    // Android: MusicProcessingViewModel.setBandGain(band, gain) -> MusicProcessingRepository.setUserSetBandGain(band, gain)
    // -> SetUserBandGainRequest -> V3MusicProcessingPlugin.setUserSetGains(band, band, [gain])
    if (activeHorizontalSliderIndex !== null && activeHorizontalSliderIndex !== undefined) {
      const horizontalEqBands = this.data.horizontalEqBands
      if (horizontalEqBands && horizontalEqBands[activeHorizontalSliderIndex]) {
        const bandIndex = activeHorizontalSliderIndex
        const gain = horizontalEqBands[activeHorizontalSliderIndex].gain
        
        try {
          console.log('🎵 [横向EQ] 设置频段增益发送:', { bandIndex, gain })
          
          // 调用gaiaManager设置频段增益，这会发送GAIA命令到设备
          const result = await gaiaManager.setUserBandGain(bandIndex, gain)
          
          if (result && result.success) {
            console.log(`🎵 [横向EQ] 频段${bandIndex}增益设置为${gain}dB成功`)
            // 同步更新主要EQ控制区域的数据
            this.syncHorizontalToMainEQ(bandIndex, gain)
            // 重新绘制图表
            this.drawEQGraph()
          } else {
            wx.showToast({
              title: '设置频段增益失败',
              icon: 'error'
            })
          }
        } catch (error) {
          console.error('🎵 [横向EQ] 设置频段增益失败:', error)
          wx.showToast({
            title: '设置频段增益失败',
            icon: 'error'
          })
        }
      }
    }
  },

  // 处理横向滑块触摸 - 与主要EQ控制区域保持一致
  handleHorizontalSliderTouch(e, bandIndex) {
    const touch = e.touches[0]
    const query = wx.createSelectorQuery()
    
    // 设置当前活动的滑块索引
    this.setData({
      isHorizontalSliderDragging: true,
      activeHorizontalSliderIndex: bandIndex
    })
    
    query.select('.horizontal-slider-wrapper').boundingClientRect((rect) => {
      if (!rect) return
      
      // 计算滑块位置
      const trackWidth = rect.width
      const touchX = touch.clientX - rect.left
      
      // 计算增益值（-12到+12）
      const percentage = Math.max(0, Math.min(1, touchX / trackWidth))
      const gain = Math.round(-12 + percentage * 24)
      
      // 更新数据
      this.updateHorizontalSliderValue(bandIndex, gain)
    }).exec()
  },

  // 更新横向滑块值 - 与主要EQ控制区域保持一致
  updateHorizontalSliderValue(bandIndex, gain) {
    const horizontalEqBands = [...this.data.horizontalEqBands]
    horizontalEqBands[bandIndex].gain = gain
    // 同步更新垂直显示的反转值
    horizontalEqBands[bandIndex].displayGain = -9 - gain
    
    this.setData({ horizontalEqBands })
    
    // 重新绘制EQ图表
    this.drawEQGraph()
  },

  // 同步横向EQ数据到主要EQ控制区域
  syncHorizontalToMainEQ(bandIndex, gain) {
    try {
      // 获取主要EQ控制区域的数据
      const eqBands = [...this.data.eqBands]
      
      // 横向EQ频段顺序：0=20Hz, 1=50Hz, ..., 9=20kHz（从左到右，低频到高频）
      // 主要EQ频段顺序：0=20Hz, 1=50Hz, ..., 9=20kHz（从左到右，低频到高频）
      // 索引直接对应：horizontalIndex -> mainIndex = horizontalIndex
      const mainBandIndex = bandIndex
      
      // 确保eqBands数组有足够的长度
      if (eqBands.length <= mainBandIndex) {
        console.log('🎵 [同步] eqBands长度不足，扩展数组')
        // 扩展数组到需要的长度
        while (eqBands.length <= mainBandIndex) {
          eqBands.push({
            frequency: this.getFrequencyByIndex(eqBands.length),
            gain: 0,
            filter: 'PARAMETRIC_EQUALIZER',
            enabled: true,
            visible: true
          })
        }
      }
      
      // 更新对应频段的增益
      if (eqBands[mainBandIndex]) {
        eqBands[mainBandIndex].gain = gain
        console.log(`🎵 [同步] 横向EQ频段${bandIndex}(${this.data.horizontalEqBands[bandIndex]?.frequency}) -> 主要EQ频段${mainBandIndex}(${eqBands[mainBandIndex]?.frequency})增益为${gain}dB`)
        
        // 更新数据
        this.setData({ eqBands })
        
        // 确保进入自定义模式
        if (!this.data.isCustomMode) {
          this.setData({ isCustomMode: true })
          console.log('🎵 [同步] 切换到自定义模式')
        }
      }
    } catch (error) {
      console.error('🎵 [同步] 同步横向EQ到主要EQ失败:', error)
    }
  },

  // 根据索引获取频率值
  getFrequencyByIndex(index) {
    const frequencies = ['20', '50', '100', '200', '500', '1k', '2k', '5k', '10k', '20k']
    return frequencies[index] || `${index + 1}k`
  },

  // 同步主要EQ数据到横向EQ控制区域
  syncMainToHorizontalEQ(bandIndex, gain) {
    try {
      // 获取横向EQ控制区域的数据
      const horizontalEqBands = [...this.data.horizontalEqBands]
      
      // 主要EQ频段顺序：0=20Hz, 1=50Hz, ..., 9=20kHz（从左到右，低频到高频）
      // 横向EQ频段顺序：0=20Hz, 1=50Hz, ..., 9=20kHz（从左到右，低频到高频）
      // 索引直接对应：mainIndex -> horizontalIndex = mainIndex
      const horizontalBandIndex = bandIndex
      
      // 确保horizontalEqBands数组有足够的长度
      if (horizontalEqBands.length <= horizontalBandIndex) {
        console.log('🎵 [反向同步] horizontalEqBands长度不足，扩展数组')
        // 扩展数组到需要的长度
        while (horizontalEqBands.length <= horizontalBandIndex) {
          horizontalEqBands.push({
            index: horizontalEqBands.length,
            frequency: this.formatHorizontalFrequency(this.getFrequencyValueByIndex(horizontalEqBands.length)),
            gain: 0,
            filter: 'PARAMETRIC_EQUALIZER',
            enabled: true,
            visible: true
          })
        }
      }
      
      // 更新对应频段的增益
      if (horizontalEqBands[horizontalBandIndex]) {
        horizontalEqBands[horizontalBandIndex].gain = gain
        horizontalEqBands[horizontalBandIndex].displayGain = -9 - gain
        console.log(`🎵 [反向同步] 主要EQ频段${bandIndex}(${this.data.eqBands[bandIndex]?.frequency}) -> 横向EQ频段${horizontalBandIndex}(${horizontalEqBands[horizontalBandIndex]?.frequency})增益为${gain}dB`)
        
        // 更新数据
        this.setData({ horizontalEqBands })
      }
    } catch (error) {
      console.error('🎵 [反向同步] 同步主要EQ到横向EQ失败:', error)
    }
  },

  // 根据索引获取频率数值
  getFrequencyValueByIndex(index) {
    const frequencies = [20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000]
    return frequencies[index] || (index + 1) * 1000
  },

  // 动态计算滑块区域高度
  calculateSliderAreaHeight() {
    // 获取系统信息
    const systemInfo = wx.getSystemInfoSync()
    const screenHeight = systemInfo.windowHeight
    const screenWidth = systemInfo.windowWidth
    
    // 根据屏幕尺寸计算合适的容器高度
    let containerHeight
    if (screenWidth <= 600) {
      // 小屏幕：250rpx
      containerHeight = 250
    } else if (screenWidth <= 750) {
      // 中等屏幕：300rpx
      containerHeight = 300
    } else if (screenWidth >= 1200) {
      // 大屏幕：450rpx
      containerHeight = 450
    } else {
      // 默认屏幕：350rpx
      containerHeight = 350
    }
    
    // 转换为px (rpx转px的比例)
    const rpxToPx = screenWidth / 750
    const heightInPx = containerHeight * rpxToPx
    
    console.log('🎵 [动态高度] 屏幕尺寸:', screenWidth, 'x', screenHeight)
    console.log('🎵 [动态高度] 计算容器高度:', containerHeight, 'rpx =', heightInPx, 'px')
    
    // 设置高度
    this.setData({
      sliderAreaHeight: heightInPx + 'px'
    })
    
    // 延迟验证实际渲染高度
    setTimeout(() => {
      this.verifyActualHeight()
    }, 200)
  },

  // 验证实际渲染高度
  verifyActualHeight() {
    const query = wx.createSelectorQuery()
    query.select('.horizontal-sliders-area').boundingClientRect((rect) => {
      if (rect) {
        console.log('🎵 [验证高度] 实际渲染高度:', rect.height, 'px')
        
        // 如果实际高度与预期不符，重新调整
        const expectedHeight = parseFloat(this.data.sliderAreaHeight)
        if (Math.abs(rect.height - expectedHeight) > 5) {
          console.log('🎵 [高度调整] 重新设置高度:', rect.height, 'px')
          this.setData({
            sliderAreaHeight: rect.height + 'px'
          })
        }
      }
    }).exec()
  },

  // 更新CSS变量
  updateSliderHeightCSS(height) {
    // 通过CSS变量动态设置高度
    const query = wx.createSelectorQuery()
    query.select('.horizontal-sliders-area').node((res) => {
      if (res && res.node) {
        res.node.style.setProperty('--slider-area-height', height + 'px')
      }
    }).exec()
    
    query.select('.k-labels-container').node((res) => {
      if (res && res.node) {
        res.node.style.setProperty('--slider-area-height', height + 'px')
      }
    }).exec()
  },

  // 强制Canvas初始化
  forceCanvasInit() {
    // 方法1：尝试新版Canvas API
    const query = wx.createSelectorQuery()
    query.select('.eq-graph')
      .fields({ node: true, size: true })
      .exec((res) => {
        if (res[0] && res[0].node) {
          // 新版API成功
          const canvas = res[0].node
          const ctx = canvas.getContext('2d')
          const dpr = wx.getSystemInfoSync().pixelRatio
          canvas.width = res[0].width * dpr
          canvas.height = res[0].height * dpr
          ctx.scale(dpr, dpr)
          
          this.setData({
            graphContext: ctx,
            canvasWidth: res[0].width,
            canvasHeight: res[0].height
          })
          
          // 延迟绘制，确保数据已更新
          setTimeout(() => {
            this.drawEQGraph()
          }, 50)
          return
        }
        
        // 方法2：使用旧版Canvas API
        const ctx = wx.createCanvasContext('eqGraph', this)
        const systemInfo = wx.getSystemInfoSync()
        const canvasWidth = systemInfo.windowWidth - 80
        const canvasHeight = 220
        
        this.setData({
          graphContext: ctx,
          canvasWidth: canvasWidth,
          canvasHeight: canvasHeight
        })
        
        // 延迟绘制，确保数据已更新
        setTimeout(() => {
          this.drawEQGraphLegacy()
        }, 50)
      })
  },

  // 可靠的Canvas初始化方法
  ensureCanvasInitialized() {
    const { graphContext, canvasWidth, canvasHeight } = this.data
    
    if (graphContext && canvasWidth > 0 && canvasHeight > 0) {
      this.drawEQGraph()
      return true
    }
    
    this.forceCanvasInit()
    return false
  },

  // 初始化画布
  initCanvas() {
    const query = wx.createSelectorQuery()
    query.select('.eq-graph')
      .fields({ node: true, size: true })
      .exec((res) => {
        if (res[0] && res[0].node) {
          // 新版Canvas API
          const canvas = res[0].node
          const ctx = canvas.getContext('2d')
          const dpr = wx.getSystemInfoSync().pixelRatio
          canvas.width = res[0].width * dpr
          canvas.height = res[0].height * dpr
          ctx.scale(dpr, dpr)
          
          this.setData({
            graphContext: ctx,
            canvasWidth: res[0].width,
            canvasHeight: res[0].height
          })
          
          // 延迟绘制，确保数据已加载
          setTimeout(() => {
            this.drawEQGraph()
          }, 100)
        } else if (res[0] && res[0].width && res[0].height) {
          // 旧版Canvas API
          this.initCanvasLegacy()
        } else {
          console.error('Canvas初始化失败，尝试延迟初始化')
          // 延迟重试
          setTimeout(() => {
            this.initCanvas()
          }, 500)
        }
      })
  },

  // 旧版Canvas初始化方法
  initCanvasLegacy() {
    const ctx = wx.createCanvasContext('eqGraph', this)
    
    // 获取系统信息
    const systemInfo = wx.getSystemInfoSync()
    
    // 计算Canvas尺寸
    const canvasWidth = systemInfo.windowWidth - 80 // 减去左右边距
    const canvasHeight = 200
    
    this.setData({
      graphContext: ctx,
      canvasWidth: canvasWidth,
      canvasHeight: canvasHeight
    })
    
    // 延迟绘制，确保数据已加载
    setTimeout(() => {
      this.drawEQGraphLegacy()
    }, 100)
  },

  // 获取EQ数据 - 从设备获取真实的EQ配置
  async getEQ() {
    try {
      console.log('🎵 [音频页面] 开始从设备获取EQ数据')
      
      // 从设备获取用户EQ配置
      const eqResponse = await audioManager.getUserSetConfiguration()
      
      if (eqResponse && eqResponse.success) {
        console.log('🎵 [音频页面] 成功获取设备EQ数据:', eqResponse.data)
        return eqResponse
      } else {
        console.warn('🎵 [音频页面] 获取EQ数据失败:', eqResponse?.error)
        // 返回失败响应
        return { success: false, error: eqResponse?.error || '获取EQ数据失败' }
      }
      
    } catch (error) {
      console.error('🎵 [音频页面] 获取EQ数据异常:', error)
      return { success: false, error: error.message }
    }
  },


  // 加载EQ数据（类似安卓版本的fetchData方法）
  async loadEQData() {
    try {
      // 如果设备未连接，不加载EQ数据
      if (!this.data.deviceConnected) {
        return
      }
      
      this.setData({ isLoading: true })
      
      // 1. 首先获取可用预设列表（从设备动态获取）
      console.log('🎵 [音频页面tab] 开始获取可用预设列表')
      const presetsResult = await gaiaManager.getAvailablePresets()
      console.log(presetsResult,"///////////////////////")
      if (presetsResult && presetsResult.success) {
        console.log('🎵 [音频页面] 可用预设列表:', presetsResult.data)
        // ===== 标记：gaiaManager.getAvailablePresets() 返回的数据结构 =====
        // presetsResult.data 是一个数组，包含以下格式的预设对象：
        // [
        //   { id: 0, type: 'OFF', value: 0, name: 'FLAT' },
        //   { id: 63, type: 'USER', value: 63, name: 'USER' },
        //   { id: 1, type: 'PRE_SET', value: 1, name: 'ROCK' },
        //   { id: 2, type: 'PRE_SET', value: 2, name: 'POP' },
        //   { id: 3, type: 'PRE_SET', value: 3, name: 'CLASSICAL' },
        //   { id: 4, type: 'PRE_SET', value: 4, name: 'TECHNO' },
        //   { id: 5, type: 'PRE_SET', value: 5, name: 'R&B' },
        //   { id: 6, type: 'PRE_SET', value: 6, name: 'AMBIENT' },
        //   { id: 7, type: 'PRE_SET', value: 7, name: 'METAL' },
        //   { id: 8, type: 'PRE_SET', value: 8, name: 'FUNK' },
        //   { id: 9, type: 'PRE_SET', value: 9, name: 'SPEECH' }
        // ]
        // 每个预设对象包含：
        // - id: 预设ID（数字）
        // - type: 预设类型（'OFF'/'USER'/'PRE_SET'）
        // - value: 预设值（与id相同）
        // - name: 预设显示名称
        // ===== 标记结束 =====
        
        // 更新预设按钮
        this.updatePresetButtons(presetsResult.data)
      } else {
        console.warn('🎵 [音频页面] 获取可用预设失败:', presetsResult?.error)
      }
      
      // 2. 获取当前预设状态
      console.log('🎵 [音频页面] 开始获取当前预设状态')
      const presetResponse = await gaiaManager.getSelectedPreset()
      if (presetResponse && presetResponse.success) {
        console.log('🎵 [音频页面] 当前预设状态:', presetResponse.data)
        // 初始化加载时不显示Toast提示
        this.updateSelectedPreset(presetResponse.data, false)
        
        // 只有在USER模式时才加载EQ数据和绘制图表
        if (presetResponse.data.type === 'USER') {
          console.log('🎵 [音频页面] USER模式，加载EQ数据')
          const eqResponse = await this.getEQ()
          
          if (eqResponse && eqResponse.success) {
            // 修复：processEQData期望的数据格式是 {userBands: [...]}
            this.processEQData({ userBands: eqResponse.data })
          }
        } else {
          console.log('🎵 [音频页面] 非USER模式，跳过EQ数据加载')
          // 非USER模式时，只更新基本状态
          this.setData({
            eqEnabled: true,
            showError: false,
            isCustomMode: false,
            showGraph: false  // 修复：非USER模式时隐藏图表
          })
        }
      } else {
        console.warn('🎵 [音频页面] 获取预设状态失败:', presetResponse?.error)
      }

    } finally {
      this.setData({ isLoading: false })
    }
  },

  // 处理BLE原始数据回调
  handleBleData(data) {
    try {
      console.log('🎵 [音频页面] 处理BLE原始数据:', data)
      
      // 使用audioManager处理BLE数据
      const audioResponse = audioManager.handleBleData(data)
      
      if (audioResponse) {
        console.log('🎵 [音频页面] 音频管理器处理成功:', audioResponse)
        // audioManager已经处理了回调，这里不需要额外处理
      } else {
        console.log('🎵 [音频页面] 非音频响应，忽略')
      }
      
    } catch (error) {
      console.error('🎵 [音频页面] 处理BLE数据失败:', error)
    }
  },

  // 解析预设状态响应数据
  parsePresetResponseData(hexData) {
    try {
      console.log('🎵 [音频页面] 解析预设状态响应数据:', hexData)
      
      // 从hexData中提取payload部分（跳过GAIA头部）
      // GAIA格式: [VENDOR_ID(2字节)] [COMMAND_VALUE(2字节)] [PAYLOAD]
      if (hexData.length < 8) {
        console.warn('🎵 [音频页面] 预设响应数据长度不足')
        return
      }
      
      const payloadHex = hexData.substring(8) // 跳过前8个字符（4字节）
      const payload = this.hexToBytes(payloadHex)
      
      console.log('🎵 [音频页面] 预设响应payload:', payload)
      
      // 调用现有的预设响应处理方法
      this.handleSelectedPresetResponse(payload)
      
    } catch (error) {
      console.error('🎵 [音频页面] 解析预设响应数据失败:', error)
    }
  },

  // 解析EQ配置响应数据
  parseEQConfigurationData(hexData) {
    try {
      console.log('///111////:', hexData)
      
      // 从hexData中提取payload部分（跳过GAIA头部）
      // GAIA格式: [VENDOR_ID(2字节)] [COMMAND_VALUE(2字节)] [PAYLOAD]
      if (hexData.length < 8) {
        console.warn('🎵 [音频页面] EQ配置响应数据长度不足')
        return
      }
      
      const payloadHex = hexData.substring(8) // 跳过前8个字符（4字节）
      const payload = this.hexToBytes(payloadHex)
      
      console.log('🎵 [音频页面] EQ配置响应payload:', payload)
      console.log('🎵 [音频页面] EQ配置响应payload长度:', payload.length)
      
      // 调用现有的EQ配置响应处理方法
      this.handleUserSetConfigurationResponse(payload)
      
    } catch (error) {
      console.error('🎵 [音频页面] 解析EQ配置响应数据失败:', error)
    }
  },

  // 解析EQ设置响应数据
  parseEQSetResponseData(hexData) {
    try {
      console.log('🎵 [音频页面] 解析EQ设置响应数据:', hexData)
      
      // 从hexData中提取payload部分（跳过GAIA头部）
      if (hexData.length < 8) {
        console.warn('🎵 [音频页面] EQ设置响应数据长度不足')
        return
      }
      
      const payloadHex = hexData.substring(8) // 跳过前8个字符（4字节）
      const payload = this.hexToBytes(payloadHex)
      
      console.log('🎵 [音频页面] EQ设置响应payload:', payload)
      
      // EQ设置响应通常只是确认，可以显示成功提示
      wx.showToast({
        title: 'EQ设置成功',
        icon: 'success',
        duration: 2000
      })
      
    } catch (error) {
      console.error('🎵 [音频页面] 解析EQ设置响应数据失败:', error)
    }
  },

  // 将十六进制字符串转换为字节数组
  hexToBytes(hex) {
    const bytes = []
    for (let i = 0; i < hex.length; i += 2) {
      bytes.push(parseInt(hex.substr(i, 2), 16))
    }
    return bytes
  },

  // 处理用户EQ配置响应
  handleUserSetConfigurationResponse(payload) {
    try {
      console.log('🎵 [音频页面] 处理用户EQ配置响应:', payload)
      
      if (payload && payload.length > 0) {
        // 解析EQ配置数据
        const userBands = gaiaManager.parseUserSetConfiguration(payload)
        console.log('🎵 [音频页面] 解析后的用户EQ配置:', userBands)
        
        // 构建EQ数据
        const eqData = {
          selectedPreset: 63, // USER 预设
          userBands: userBands
        }
        
        // 处理EQ数据并更新UI
        this.processEQData(eqData)
        
        console.log('🎵 [音频页面] 用户EQ配置处理完成')
      } else {
        console.warn('🎵 [音频页面] 用户EQ配置响应数据为空')
      }
    } catch (error) {
      console.error('🎵 [音频页面] 处理用户EQ配置响应失败:', error)
    }
  },

  // 处理当前预设状态响应
  handleSelectedPresetResponse(payload) {
    try {
      console.log('🎵 [音频页面] 处理预设状态响应:', payload)
      
      if (payload && payload.length >= 1) {
        const presetValue = payload[0]
        console.log(`🎵 [音频页面] 预设值: 0x${presetValue.toString(16).padStart(2, '0')} (${presetValue})`)
        
        // 根据预设值确定预设类型和名称
        let presetType, presetName
        if (presetValue === 0x00) {
          presetType = 'OFF'
          presetName = 'FLAT'
        } else if (presetValue === 0x3F) {
          presetType = 'USER'
          presetName = 'USER'
        } else {
          presetType = 'PRE_SET'
          // 根据预设值映射到具体名称
          const presetNames = {
            1: 'ROCK',
            2: 'POP', 
            3: 'CLASSICAL',
            4: 'TECHNO',
            5: 'R&B',
            6: 'AMBIENT',
            7: 'METAL',
            8: 'FUNK',
            9: 'SPEECH'
          }
          presetName = presetNames[presetValue] || `PRESET ${presetValue}`
        }
        
        console.log(`🎵 [音频页面] 当前预设: ${presetName} (${presetType})`)
        if(presetName=='USER'){
          this.loadEQDataForUserMode()
        }
        // 更新页面数据 - 响应处理时不显示Toast提示
        this.updateSelectedPreset({
          type: presetType,
          value: presetValue,
          name: presetName
        }, false)
      }
    } catch (error) {
      console.error('🎵 [音频页面] 处理预设状态响应失败:', error)
    }
  },

  // 更新选中的预设
  updateSelectedPreset(presetData, showToast = true) {
    try {
      console.log('🎵 [音频页面] 更新选中预设:', presetData, '显示Toast:', showToast)
      
      // 更新selectedPreset和showGraph状态
      this.setData({
        selectedPreset: presetData.value,
        showGraph: presetData.type === 'USER'  // 修复：只有USER模式才显示图表
      })
      
      // 更新预设按钮的选中状态和高亮显示
      this.updatePresetButtonsState(presetData.value)
      
      // 显示当前预设信息
      console.log(`🎵 [音频页面] 当前预设状态: ${presetData.name} (${presetData.type})`)
      
      // 只有在需要时才显示高亮回显效果（避免EQ拖动时的干扰）
      if (showToast) {
        this.showPresetHighlight(presetData)
      }
      
    } catch (error) {
      console.error('🎵 [音频页面] 更新选中预设失败:', error)
    }
  },

  // 显示预设高亮回显效果
  showPresetHighlight(presetData) {
    try {
      console.log(`🎵 [音频页面] 高亮显示预设: ${presetData.name}`)
      
      // 显示Toast提示
      wx.showToast({
        title: `当前预设: ${presetData.name}`,
        icon: 'none',
        duration: 2000
      })
      
      // 可以添加其他视觉效果，比如震动反馈
      wx.vibrateShort({
        type: 'light'
      })
      
    } catch (error) {
      console.error('🎵 [音频页面] 显示预设高亮失败:', error)
    }
  },

  // 更新预设按钮状态
  updatePresetButtonsState(selectedValue) {
    try {
      // 更新预设按钮的选中状态
      const presets = this.data.presets.map(preset => ({
        ...preset,
        selected: preset.value === selectedValue
      }))
      
      this.setData({ presets })
      
      // 重新分配预设到行
      this.updatePresetButtons()
      
    } catch (error) {
      console.error('🎵 [音频页面] 更新预设按钮状态失败:', error)
    }
  },

  // 处理EQ数据
  processEQData(eqData) {    
    // 解析用户频段
    const userBands = this.parseUserBands(eqData.userBands || [])
    
    // 修复：正确处理selectedPreset，确保能找到对应的预设对象
    let selectedPreset = null
    const currentSelectedValue = this.data.selectedPreset
    
    if (currentSelectedValue !== null && currentSelectedValue !== undefined) {
      // 根据当前选中的值找到对应的预设对象
      selectedPreset = this.data.presets.find(p => p.value === currentSelectedValue)
    }
    
    // 如果还是找不到，使用默认的USER预设
    if (!selectedPreset) {
      selectedPreset = this.data.presets.find(p => p.type === 'USER') || this.data.presets[0]
    }
    
    console.log('🎵 [音频页面] 处理EQ数据，当前选中值:', currentSelectedValue, '找到的预设对象:', selectedPreset)
    
    // 更新数据 - 先不显示图表和控制区域
    this.setData({
      selectedPreset: selectedPreset.value, // 保持值为数字
      userBands,
      eqEnabled: true,
      showError: false,
    }, () => {
      // 数据更新完成后更新UI
      // 注意：不要调用updatePresetButtons()，避免影响EQ控制时的预设状态
      this.updateEQBands()
      
      // 更新横向EQ频段数据（使用动态频率）
      this.updateHorizontalEqBands(userBands)
      
      // 只有在USER模式时才显示图表和控制区域
      if (selectedPreset && selectedPreset.type === 'USER') {
        console.log('🎵 [音频页面] USER模式，显示图表')
        // 先显示图表，确保Canvas元素渲染到DOM
        this.setData({ showGraph: true }, () => {
          // 等待DOM更新后再初始化Canvas
          setTimeout(() => {
            this.drawChartAfterDataLoad()
          }, 100)
        })
      } else {
        console.log('🎵 [音频页面] 非USER模式，隐藏图表')
        // 非USER模式时隐藏图表
        this.setData({ showGraph: false })
      }
    })
  },

  // 解析预设列表
  parsePresets(presetsData) {
    const presets = []
    
    // 首先添加 USER 预设（保持在第一位）
    presets.push({
      type: 'USER',
      value: 63, // 使用与安卓版本一致的 USER 值
      name: 'USER'
    })
    
    // 添加 FLAT 预设
    presets.push({
      type: 'OFF',
      value: 0,
      name: 'FLAT'
    })
    
    // 添加数字预设
    for (let i = 1; i <= 9; i++) {
      const presetName = this.getPresetName(i)
      presets.push({
        type: 'NUMBERED',
        value: i,
        name: presetName
      })
    }
    
    return presets
  },

  // 获取预设名称
  getPresetName(value) {
    const presetNames = {
      1: 'ROCK',
      2: 'POP',
      3: 'CLASSICAL',
      4: 'TECHNO',
      5: 'R&B',
      6: 'AMBIENT',
      7: 'METAL',
      8: 'FUNK',
      9: 'SPEECH'
    }
    return presetNames[value] || `PRESET ${value}`
  },

  // 解析用户频段
  parseUserBands(bandsData) {
    // 支持动态频率数据（从设备获取）或使用默认频率
    const bands = []
    
    for (let i = 0; i < bandsData.length; i++) {
      const bandData = bandsData[i] || {}
      bands.push({
        index: i,
        frequency: this.formatFrequency(bandData.frequency || this.getDefaultFrequency(i)),
        gain: bandData.gain || 0,
        filter: bandData.filter || 'PARAMETRIC_EQUALIZER',
        enabled: true,
        visible: true,
        q: bandData.q || 0.7, // 添加Q值支持
        id: bandData.id || i // 添加频段ID支持
      })
    }
    
    return bands
  },

  // 获取默认频率（当设备没有提供频率数据时使用）
  getDefaultFrequency(index) {
    const defaultFrequencies = [60, 170, 310, 600, 1000, 3000, 6000, 12000, 14000, 16000]
    return defaultFrequencies[index] || 1000
  },

  // 解析频率字符串（如"1K" -> 1000）
  parseFrequencyString(freqStr) {
    if (typeof freqStr === 'number') {
      return freqStr
    }
    
    const str = freqStr.toString().toUpperCase()
    if (str.includes('K')) {
      const num = parseFloat(str.replace('K', ''))
      return num * 1000
    } else {
      return parseFloat(str) || 1000
    }
  },

  // 格式化频率显示
  formatFrequency(frequency) {
    if (frequency < 999) {
      return frequency.toString()
    }
    
    const thousands = frequency / 1000.0
    if (frequency % 1000 === 0) {
      return `${thousands.toFixed(0)}K`
    } else {
      return `${thousands.toFixed(1)}K`
    }
  },

  // 更新预设按钮
  updatePresetButtons(presetsData = null) {
    // 如果传入了预设数据，则更新页面的presets数据
    if (presetsData) {
      console.log('🎵 [音频页面] 更新预设数据:', presetsData)
      this.setData({ presets: presetsData })
    }
    
    const { presets, selectedPreset } = this.data
    
    console.log('🎵 [音频页面] 更新预设按钮，当前选中值:', selectedPreset)
    
    // 每行4个按钮的布局
    const presetRow1 = [] // 前4个预设
    const presetRow2 = [] // 第5-8个预设
    const presetRow3 = [] // 第9-12个预设
    const presetRow4 = [] // 第13-16个预设
    
    presets.forEach((preset, index) => {
      // 修复选中状态判断逻辑
      const isSelected = selectedPreset === preset.value
      
      const buttonData = {
        preset: preset,
        name: preset.name,
        visible: true,
        selected: isSelected,
        // 添加高亮样式类名
        selectedClass: isSelected ? 'preset-selected' : 'preset-normal'
      }
            
      // 根据索引分配到不同行
      if (index < 4) {
        presetRow1.push(buttonData)
      } else if (index < 8) {
        presetRow2.push(buttonData)
      } else if (index < 12) {
        presetRow3.push(buttonData)
      } else {
        presetRow4.push(buttonData)
      }
    })
    
    this.setData({ 
      presetRow1,
      presetRow2,
      presetRow3,
      presetRow4
    })
    
    console.log('🎵 [音频页面] 预设按钮更新完成')
  },

  // 更新EQ频段
  updateEQBands() {
    const { selectedPreset, userBands, presets } = this.data
    
    // 根据selectedPreset值找到对应的预设对象
    const presetObj = presets.find(p => p.value === selectedPreset)
    const isCustom = presetObj && presetObj.type === 'USER'
    
    const eqBands = userBands.map(band => ({
      ...band,
      enabled: isCustom,
      visible: true
    }))
    
    this.setData({
      eqBands,
      isCustomMode: isCustom
    })
  },

  // 数据加载完成后绘制图表
  drawChartAfterDataLoad() {
    // 检查Canvas是否已初始化
    const { graphContext, canvasWidth, canvasHeight } = this.data
    
    if (graphContext && canvasWidth > 0 && canvasHeight > 0) {
      this.drawEQGraph()
    } else {
      // 先初始化Canvas，然后绘制
      this.forceCanvasInit()
    }
  },

  // 绘制默认图表（设备未连接时）
  drawDefaultChart() {
    // 设置默认数据
    const defaultBands = [
      { frequency: '60', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '170', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '310', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '600', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '1K', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '3K', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '6K', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '12K', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '14K', gain: 0, filter: 'PARAMETRIC_EQUALIZER' },
      { frequency: '16K', gain: 0, filter: 'PARAMETRIC_EQUALIZER' }
    ]
    
    this.setData({
      eqBands: defaultBands,
      isCustomMode: false,
      deviceConnected: false
    }, () => {
      // 数据设置完成后绘制图表
      this.drawChartAfterDataLoad()
    })
  },

  // 选择预设 - 与Android版本保持一致
  async selectPreset(e) {
    const preset = e.currentTarget.dataset.preset
    if (!preset) return
    if(preset.type === 'USER'){
     await this.getInitCanvas()
    }
    try {
      console.log('🎵 [音频页面] 选择预设11111111111:', preset)
      
      // 直接调用gaiaManager发送GAIA命令，与Android版本保持一致
      // Android: V3MusicProcessingPlugin.selectSet(PreSet set) -> sendPacket(COMMANDS.V1_SET_EQ_SET, set.getValue())
      const response = await gaiaManager.selectPreset(preset)
      
      if (response && response.success) {
        console.log('🎵 [音频页面] 预设设置成功:', preset)
        
        // 更新UI状态 - 先隐藏图表
        this.setData({ 
          selectedPreset: preset.value,
          isCustomMode: preset.type === 'USER',
        })
        
        // 更新预设按钮状态
        this.updatePresetButtons()
        this.updateEQBands()
        
        // 如果是USER模式，加载EQ数据并绘制图表
        if (preset.type === 'USER') {
          console.log('🎵 [音频页面] USER模式，加载EQ数据并绘制图表')
          // 先显示图表，确保Canvas元素渲染到DOM
          this.setData({ showGraph: true }, () => {
            // 等待DOM更新后再加载EQ数据
            setTimeout(() => {
              this.loadEQDataForUserMode()
            }, 100)
          })
        } else {
          console.log('🎵 [音频页面] 非USER模式，隐藏图表')
          this.setData({ 
            isCustomMode: false,
            showGraph: false  // 修复：非USER模式时隐藏图表
          })
        }
        
        // 显示成功提示
        wx.showToast({
          title: `已切换到${preset.name}`,
          icon: 'success'
        })
      } else {
        console.error('🎵 [音频页面] 预设设置失败:', response?.error)
        wx.showToast({
          title: '设置预设失败',
          icon: 'error'
        })
      }
    } catch (error) {
      console.error('🎵 [音频页面] 选择预设异常:', error)
      wx.showToast({
        title: '选择预设失败',
        icon: 'error'
      })
    }
  },

  // 为USER模式加载EQ数据
  async loadEQDataForUserMode() {
    try {
      console.log('🎵 [音频页面] 为USER模式加载EQ数据')
      
      // 获取EQ状态
      const eqResponse = await this.getEQ()
      
      if (eqResponse && eqResponse.success) {
        // 修复：processEQData期望的数据格式是 {userBands: [...]}
        this.processEQData({ userBands: eqResponse.data })
      } else {
        console.warn('🎵 [音频页面] 获取EQ数据失败')
      }
    } catch (error) {
      console.error('🎵 [音频页面] 加载USER模式EQ数据失败:', error)
    }
  },

  // 滑块触摸开始
  onSliderTouchStart(e) {
    const bandIndex = parseInt(e.currentTarget.dataset.band)
    console.log('滑块触摸开始，频段索引:', bandIndex)
    this.setData({
      activeSliderIndex: bandIndex,
      isSliderDragging: true
    })
    
    // 立即处理触摸位置
    this.handleSliderTouch(e, bandIndex)
  },

  // 滑块触摸移动
  onSliderTouchMove(e) {
    if (!this.data.isSliderDragging) return
    
    const bandIndex = parseInt(e.currentTarget.dataset.band)
    this.handleSliderTouch(e, bandIndex)
  },

  // 滑块触摸结束 - 与Android版本保持一致
  async onSliderTouchEnd(e) {
    // 先保存当前活动的滑块索引，然后再清除状态
    const { activeSliderIndex } = this.data
    console.log('🎵 [音频页面] 滑动结束，当前活动滑块索引:', activeSliderIndex)
    
    // 清除滑动状态
    this.setData({
      isSliderDragging: false,
      activeSliderIndex: null
    })
    
    // 参考安卓版本逻辑：滑动结束后发送频段增益命令
    // Android: MusicProcessingViewModel.setBandGain(band, gain) -> MusicProcessingRepository.setUserSetBandGain(band, gain)
    // -> SetUserBandGainRequest -> V3MusicProcessingPlugin.setUserSetGains(band, band, [gain])
    if (activeSliderIndex !== null && activeSliderIndex !== undefined) {
      const eqBands = this.data.eqBands
      if (eqBands && eqBands[activeSliderIndex]) {
        const bandIndex = activeSliderIndex
        const gain = eqBands[activeSliderIndex].gain
        
        try {
          console.log('🎵 [音频页面] 设置频段增益发送1111:', { bandIndex, gain })
          
          // 调用gaiaManager设置频段增益，这会发送GAIA命令到设备
          const result = await gaiaManager.setUserBandGain(bandIndex, gain)
          
        if (result && result.success) {
          console.log(`🎵 [音频页面] 频段${bandIndex}增益设置为${gain}dB成功`)
          // 同步更新横向EQ控制区域的数据
          this.syncMainToHorizontalEQ(bandIndex, gain)
        } else {
            wx.showToast({
              title: '设置频段增益失败',
              icon: 'error'
            })
          }
        } catch (error) {
          console.error('🎵 [音频页面] 设置频段增益异常:', error)
          wx.showToast({
            title: '设置频段增益失败',
            icon: 'error'
          })
        }
      }
    }
  },

  // 处理滑块触摸
  handleSliderTouch(e, bandIndex) {
    const touch = e.touches[0]
    const query = wx.createSelectorQuery()
    
    // 设置当前活动的滑块索引
    this.setData({
      isSliderDragging: true,
      activeSliderIndex: bandIndex
    })
    
    query.select('.slider-track').boundingClientRect((rect) => {
      if (!rect) return
      
      // 计算滑块位置
      const trackHeight = rect.height
      const touchY = touch.clientY - rect.top
      const percentage = Math.max(0, Math.min(1, 1 - touchY / trackHeight))
      
      // 计算增益值 (-18dB 到 +12dB)
      const gain = Math.round(percentage * 30 - 18)
      
      // 更新滑块值（仅更新UI，不发送命令）
      this.updateSliderValue(bandIndex, gain)
    }).exec()
  },

  // 更新滑块值（仅更新UI，不发送命令）
  updateSliderValue(bandIndex, gain) {
    const eqBands = [...this.data.eqBands]
    eqBands[bandIndex].gain = gain
    
    this.setData({ eqBands })
    
    // 重新绘制EQ图表
    this.drawEQGraph()
  },

  // 发送EQ设置
  async sendEQSettings(gains) {
    try {
      const response = await gaiaManager.setEQ(gains)
      if (response && response.success) {
        this.drawEQGraph()
      } else {
        wx.showToast({
          title: '设置EQ失败',
          icon: 'error'
        })
      }
    } catch (error) {
      console.error('设置EQ失败:', error)
      wx.showToast({
        title: '设置EQ失败',
        icon: 'error'
      })
    }
  },

  // 滑块变化处理（保留原有方法以兼容）
  async onSliderChange(e) {
    const { value } = e.detail
    const bandIndex = e.currentTarget.dataset.band
    
    if (bandIndex === undefined) return
    
    try {
      // 更新本地数据
      const eqBands = [...this.data.eqBands]
      eqBands[bandIndex].gain = value
      
      this.setData({ eqBands })
      
      // 发送EQ设置命令
      const gains = eqBands.map(band => band.gain)
      const response = await gaiaManager.setEQ(gains)
      
      if (response && response.success) {
        // 同步更新横向EQ控制区域的数据
        this.syncMainToHorizontalEQ(bandIndex, value)
        this.drawEQGraph()
      } else {
        wx.showToast({
          title: '设置EQ失败',
          icon: 'error'
        })
      }
    } catch (error) {
      console.error('设置EQ失败:', error)
      wx.showToast({
        title: '设置EQ失败',
        icon: 'error'
      })
    }
  },

  // 绘制EQ图表
  drawEQGraph() {
    const { graphContext, canvasWidth, canvasHeight, eqBands, isCustomMode } = this.data
    
    if (!graphContext || !canvasWidth || !canvasHeight) {
      console.error('❌ Canvas上下文或尺寸未初始化')
      console.log('🎵 [音频页面] 尝试重新初始化Canvas')
      // 不要无限重试，只尝试一次
      setTimeout(() => {
        this.initCanvasWithRetry(0)
      }, 200)
      return
    }
    
    const ctx = graphContext
    
    // 检查是否是旧版Canvas API
    if (typeof ctx.setFillStyle === 'function') {
      this.drawEQGraphLegacy()
      return
    }
    
    // 使用新版API
    // 清空画布
    ctx.clearRect(0, 0, canvasWidth, canvasHeight)
    
    // 绘制测试背景
    ctx.fillStyle = '#f8f8f8'
    ctx.fillRect(0, 0, canvasWidth, canvasHeight)
    
    // 绘制边框
    ctx.strokeStyle = '#ddd'
    ctx.lineWidth = 1
    ctx.strokeRect(0, 0, canvasWidth, canvasHeight)
    
    // 绘制背景网格
    this.drawGrid(ctx, canvasWidth, canvasHeight)
    
    // 绘制频率响应曲线
    if (isCustomMode && eqBands && eqBands.length > 0) {
      this.drawFrequencyResponse(ctx, canvasWidth, canvasHeight, eqBands)
    } else {
      this.drawFlatResponse(ctx, canvasWidth, canvasHeight)
    }
    
    // 绘制测试文本
    ctx.fillStyle = '#333'
    ctx.font = '12px Arial'
    ctx.textAlign = 'center'
    ctx.fillText('EQ图表', canvasWidth / 2, 30)
  },

  // 绘制频率响应曲线
  drawFrequencyResponse(ctx, width, height, bands) {
    ctx.strokeStyle = '#FF0000' // 红色曲线，与参考图片一致
    ctx.lineWidth = 2
    ctx.beginPath()
    
    // 定义图表区域，与网格绘制保持一致
    const chartLeft = 40
    const chartRight = width - 10
    const chartTop = 10
    const chartBottom = height - 30
    const chartWidth = chartRight - chartLeft
    const chartHeight = chartBottom - chartTop
    
    // 使用动态频率数据（从设备获取）或默认频率
    const frequencies = bands.map((band, index) => {
      // 如果band.frequency是字符串（如"1K"），需要转换为数值
      if (typeof band.frequency === 'string') {
        return this.parseFrequencyString(band.frequency)
      }
      return band.frequency || this.getDefaultFrequency(index)
    })
    
    frequencies.forEach((freq, index) => {
      // 对数映射到x坐标 - 调整方向与EQ控制保持一致
      const logFreq = Math.log10(freq)
      const logMin = Math.log10(20)
      const logMax = Math.log10(20000)
      // 正常x轴方向：从左到右（低频到高频）
      const x = chartLeft + ((logFreq - logMin) / (logMax - logMin)) * chartWidth
      
      const gain = bands[index] ? bands[index].gain : 0
      // 调整映射范围：从+3dB到-12dB映射到0到height，与EQ控制保持一致
      const y = chartTop + ((3 - gain) / 15) * chartHeight
      
      if (index === 0) {
        ctx.moveTo(x, y)
      } else {
        ctx.lineTo(x, y)
      }
    })
    
    ctx.stroke()
  },

  // 绘制平直响应
  drawFlatResponse(ctx, width, height) {
    ctx.strokeStyle = '#999'
    ctx.lineWidth = 2
    ctx.setLineDash([5, 5])
    
    // 定义图表区域，与网格绘制保持一致
    const chartLeft = 40
    const chartRight = width - 10
    const chartTop = 10
    const chartBottom = height - 30
    const chartHeight = chartBottom - chartTop
    
    // 0dB位置，与EQ控制保持一致
    const y = chartTop + ((3 - 0) / 15) * chartHeight
    
    ctx.beginPath()
    ctx.moveTo(chartLeft, y)
    ctx.lineTo(chartRight, y)
    ctx.stroke()
    
    ctx.setLineDash([])
  },

  // 绘制网格
  drawGrid(ctx, width, height) {
    ctx.strokeStyle = '#e0e0e0'
    ctx.lineWidth = 1
    
    // 定义图表区域，为标签留出空间
    const chartLeft = 40  // 左侧留出40px给Y轴标签
    const chartRight = width - 10  // 右侧留出10px边距
    const chartTop = 10   // 顶部留出10px边距
    const chartBottom = height - 30  // 底部留出30px给X轴标签
    const chartWidth = chartRight - chartLeft
    const chartHeight = chartBottom - chartTop
    
    // 水平网格线（增益）- 与EQ控制保持一致：+3dB到-12dB，每3dB一条线
    const gainSteps = [3, 0, -3, -6, -9, -12]
    gainSteps.forEach((gain, index) => {
      const y = chartTop + (index / (gainSteps.length - 1)) * chartHeight
      ctx.beginPath()
      ctx.moveTo(chartLeft, y)
      ctx.lineTo(chartRight, y)
      ctx.stroke()
    })
    
    // 垂直网格线（频率）- 对数刻度，按照参考图片
    const freqSteps = [20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 20000]
    freqSteps.forEach((freq) => {
      // 对数映射到x坐标
      const logFreq = Math.log10(freq)
      const logMin = Math.log10(20)
      const logMax = Math.log10(20000)
      // 正常x轴方向：从左到右（低频到高频）
      const x = chartLeft + ((logFreq - logMin) / (logMax - logMin)) * chartWidth
      
      ctx.beginPath()
      ctx.moveTo(x, chartTop)
      ctx.lineTo(x, chartBottom)
      ctx.stroke()
    })
    
    // 添加频率标签（横轴）
    ctx.fillStyle = '#666'
    ctx.font = '12px Arial'
    ctx.textAlign = 'center'
    
    // 主要频率标签：100Hz, 1K, 10K - 放在X轴下方，与参考图片一致
    const mainFreqs = [100, 1000, 10000]
    mainFreqs.forEach((freq) => {
      const logFreq = Math.log10(freq)
      const logMin = Math.log10(20)
      const logMax = Math.log10(20000)
      // 正常x轴方向：从左到右（低频到高频）
      const x = chartLeft + ((logFreq - logMin) / (logMax - logMin)) * chartWidth
      const label = freq >= 1000 ? `${freq/1000}K` : freq.toString()
      ctx.fillText(label, x, height - 10) // 放在X轴下方，与参考图片一致
    })
    
    // 添加增益标签（竖轴）- 放在Y轴左侧，与EQ控制保持一致
    ctx.textAlign = 'right'
    const mainGains = [3, 0, -3, -6, -9, -12]
    mainGains.forEach((gain) => {
      const y = chartTop + ((3 - gain) / 15) * chartHeight
      const label = `${gain}`
      ctx.fillText(label, 35, y + 4) // 放在Y轴左侧，与EQ控制保持一致
    })
  },

  // 旧版Canvas绘制方法
  drawEQGraphLegacy() {
    const { graphContext, canvasWidth, canvasHeight, eqBands, isCustomMode } = this.data
    
    if (!graphContext || !canvasWidth || !canvasHeight) {
      console.error('Canvas上下文或尺寸未初始化')
      return
    }
    
    const ctx = graphContext
    
    // 清空画布
    ctx.clearRect(0, 0, canvasWidth, canvasHeight)
    
    // 绘制测试背景
    ctx.setFillStyle('#f8f8f8')
    ctx.fillRect(0, 0, canvasWidth, canvasHeight)
    
    // 绘制边框
    ctx.setStrokeStyle('#ddd')
    ctx.setLineWidth(1)
    ctx.strokeRect(0, 0, canvasWidth, canvasHeight)
    
    // 绘制网格
    this.drawGridLegacy(ctx, canvasWidth, canvasHeight)
    
    // 绘制频率响应曲线
    if (isCustomMode && eqBands && eqBands.length > 0) {
      this.drawFrequencyResponseLegacy(ctx, canvasWidth, canvasHeight, eqBands)
    } else {
      this.drawFlatResponseLegacy(ctx, canvasWidth, canvasHeight)
    }
    
    // 绘制测试文本
    ctx.setFillStyle('#333')
    ctx.setFontSize(12)
    ctx.setTextAlign('center')
    ctx.fillText('EQ图表', canvasWidth / 2, 30)
    
    // 必须调用draw()方法才能显示
    ctx.draw()
  },

  // 旧版网格绘制
  drawGridLegacy(ctx, width, height) {
    ctx.setStrokeStyle('#e0e0e0')
    ctx.setLineWidth(1)
    
    // 定义图表区域，为标签留出空间
    const chartLeft = 40  // 左侧留出40px给Y轴标签
    const chartRight = width - 10  // 右侧留出10px边距
    const chartTop = 10   // 顶部留出10px边距
    const chartBottom = height - 30  // 底部留出30px给X轴标签
    const chartWidth = chartRight - chartLeft
    const chartHeight = chartBottom - chartTop
    
    // 水平网格线（增益）- 与EQ控制保持一致：+3dB到-12dB，每3dB一条线
    const gainSteps = [3, 0, -3, -6, -9, -12]
    gainSteps.forEach((gain, index) => {
      const y = chartTop + (index / (gainSteps.length - 1)) * chartHeight
      ctx.beginPath()
      ctx.moveTo(chartLeft, y)
      ctx.lineTo(chartRight, y)
      ctx.stroke()
    })
    
    // 垂直网格线（频率）- 对数刻度，按照参考图片
    const freqSteps = [20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400, 500, 600, 700, 800, 900, 1000, 2000, 3000, 4000, 5000, 6000, 7000, 8000, 9000, 10000, 20000]
    freqSteps.forEach((freq) => {
      // 对数映射到x坐标
      const logFreq = Math.log10(freq)
      const logMin = Math.log10(20)
      const logMax = Math.log10(20000)
      // 正常x轴方向：从左到右（低频到高频）
      const x = chartLeft + ((logFreq - logMin) / (logMax - logMin)) * chartWidth
      
      ctx.beginPath()
      ctx.moveTo(x, chartTop)
      ctx.lineTo(x, chartBottom)
      ctx.stroke()
    })
    
    // 添加频率标签（横轴）
    ctx.setFillStyle('#666')
    ctx.setFontSize(12)
    ctx.setTextAlign('center')
    
    // 主要频率标签：100Hz, 1K, 10K - 放在X轴下方，与参考图片一致
    const mainFreqs = [100, 1000, 10000]
    mainFreqs.forEach((freq) => {
      const logFreq = Math.log10(freq)
      const logMin = Math.log10(20)
      const logMax = Math.log10(20000)
      // 正常x轴方向：从左到右（低频到高频）
      const x = chartLeft + ((logFreq - logMin) / (logMax - logMin)) * chartWidth
      const label = freq >= 1000 ? `${freq/1000}K` : freq.toString()
      ctx.fillText(label, x, height - 10) // 放在X轴下方，与参考图片一致
    })
    
    // 添加增益标签（竖轴）- 放在Y轴左侧，与EQ控制保持一致
    ctx.setTextAlign('right')
    const mainGains = [3, 0, -3, -6, -9, -12]
    mainGains.forEach((gain) => {
      const y = chartTop + ((3 - gain) / 15) * chartHeight
      const label = `${gain}`
      ctx.fillText(label, 35, y + 4) // 放在Y轴左侧，与EQ控制保持一致
    })
  },

  // 旧版频率响应曲线绘制
  drawFrequencyResponseLegacy(ctx, width, height, bands) {
    ctx.setStrokeStyle('#FF0000') // 红色曲线，与参考图片一致
    ctx.setLineWidth(2)
    ctx.beginPath()
    
    // 定义图表区域，与网格绘制保持一致
    const chartLeft = 40
    const chartRight = width - 10
    const chartTop = 10
    const chartBottom = height - 30
    const chartWidth = chartRight - chartLeft
    const chartHeight = chartBottom - chartTop
    
    // 使用动态频率数据（从设备获取）或默认频率
    const frequencies = bands.map((band, index) => {
      // 如果band.frequency是字符串（如"1K"），需要转换为数值
      if (typeof band.frequency === 'string') {
        return this.parseFrequencyString(band.frequency)
      }
      return band.frequency || this.getDefaultFrequency(index)
    })
    
    frequencies.forEach((freq, index) => {
      // 对数映射到x坐标
      const logFreq = Math.log10(freq)
      const logMin = Math.log10(20)
      const logMax = Math.log10(20000)
      // 正常x轴方向：从左到右（低频到高频）
      const x = chartLeft + ((logFreq - logMin) / (logMax - logMin)) * chartWidth
      
      const gain = bands[index] ? bands[index].gain : 0
      // 调整映射范围：从+3dB到-12dB映射到0到height，与EQ控制保持一致
      const y = chartTop + ((3 - gain) / 15) * chartHeight
      
      if (index === 0) {
        ctx.moveTo(x, y)
      } else {
        ctx.lineTo(x, y)
      }
    })
    
    ctx.stroke()
  },

  // 旧版平直响应绘制
  drawFlatResponseLegacy(ctx, width, height) {
    ctx.setStrokeStyle('#999')
    ctx.setLineWidth(2)
    ctx.setLineDash([5, 5])
    
    // 定义图表区域，与网格绘制保持一致
    const chartLeft = 40
    const chartRight = width - 10
    const chartTop = 10
    const chartBottom = height - 30
    const chartHeight = chartBottom - chartTop
    
    // 0dB位置，与EQ控制保持一致
    const y = chartTop + ((3 - 0) / 15) * chartHeight
    
    ctx.beginPath()
    ctx.moveTo(chartLeft, y)
    ctx.lineTo(chartRight, y)
    ctx.stroke()
    
    ctx.setLineDash([])
  },

  // 测试绘制图表
  testDrawGraph() {
    // 强制初始化Canvas
    this.forceCanvasInit()
    
    // 延迟再次尝试绘制
    setTimeout(() => {
      this.ensureCanvasInitialized()
    }, 500)
  },

  // 强制重新绘制
  forceRedraw() {
    // 清空Canvas状态
    this.setData({
      graphContext: null,
      canvasWidth: 0,
      canvasHeight: 0
    })
    
    // 重新初始化
    setTimeout(() => {
      this.forceCanvasInit()
    }, 100)
  },

  // 显示错误
  showError(message) {
    this.setData({
      showError: true,
      errorMessage: message,
      isLoading: false,
      deviceConnected: false
    })
  },

  // 重试连接设备
  async retryConnection() {
    try {
      this.setData({ isLoading: true, showError: false })
      
      // 先检查当前连接状态
      const isConnected = await this.checkConnectionStatus()
      if (isConnected) {
        return
      }
      
      // 尝试重新连接设备
      const lastDeviceId = wx.getStorageSync('lastConnectedDevice')
      if (lastDeviceId) {
        const deviceInfo = wx.getStorageSync('connectedDeviceInfo')
        
        // 检查蓝牙管理器是否可用
        if (!bluetoothManager || typeof bluetoothManager.connectDevice !== 'function') {
          this.showError('蓝牙管理器不可用，请重新启动应用')
          return
        }
        
        const connectResult = await bluetoothManager.connectDevice(lastDeviceId, deviceInfo?.name)
        
        if (connectResult.success) {
          // 连接成功，更新连接状态
          this.onConnectionStateChanged(true)
        } else {
          this.showError('重连失败，请检查设备是否开启并重新连接')
        }
      } else {
        this.showError('未找到上次连接的设备，请重新扫描并连接设备')
      }
    } catch (error) {
      console.error('重试连接失败:', error)
      this.showError('重连失败: ' + error.message)
    }
  },

  // 跳转到设备发现页面
  goToDiscovery() {
    wx.navigateTo({
      url: '/pages/discovery/discovery'
    })
  },

  // 设置连接状态监听器（类似安卓版本的观察者模式）
  setupConnectionListener() {
    // 检查蓝牙管理器是否可用
    if (!bluetoothManager || typeof bluetoothManager.setOnConnectionStateChange !== 'function') {
      console.error('蓝牙管理器不可用或方法不存在')
      return
    }
    
    // 监听蓝牙连接状态变化
    bluetoothManager.setOnConnectionStateChange((connected) => {
      this.onConnectionStateChanged(connected)
    })
  },

  // 移除连接状态监听器
  removeConnectionListener() {
    // 检查蓝牙管理器是否可用
    if (bluetoothManager && typeof bluetoothManager.setOnConnectionStateChange === 'function') {
      // 移除监听器
      bluetoothManager.setOnConnectionStateChange(null)
    }
  },

  // 连接状态变化处理（类似安卓版本的onConnectionStateUpdated）
  onConnectionStateChanged(connected) {
    const oldData = this.data
    const newData = {
      deviceConnected: connected,
      eqEnabled: connected ? oldData.eqEnabled : false,
      selectedPreset: connected ? oldData.selectedPreset : null,
      userBands: connected ? oldData.userBands : [],
      showError: !connected,
      errorMessage: connected ? '' : '设备未连接，请先连接设备'
    }
    
    this.setData(newData)
    
    // 如果设备已连接，重新加载EQ数据
    if (connected) {
      this.loadEQData()
    }
  },

  // 检查连接状态（类似安卓版本的连接状态检查）
  async checkConnectionStatus() {
    try {
      // 检查蓝牙管理器是否可用
      if (!bluetoothManager) {
        console.error('蓝牙管理器不可用')
        this.onConnectionStateChanged(false)
        return false
      }
      
      // 方法1：检查蓝牙管理器连接状态
      const isBluetoothConnected = bluetoothManager.isConnected
      
      // 方法2：检查微信小程序层面的连接状态
      let isWxConnected = false
      try {
        const connectedDevices = await wx.getConnectedBluetoothDevices({
          services: []
        })
        isWxConnected = connectedDevices.devices && connectedDevices.devices.length > 0
      } catch (error) {
        console.warn('检查微信连接状态失败:', error)
      }
      
      // 方法3：检查存储的设备信息
      const connectedDeviceInfo = wx.getStorageSync('connectedDeviceInfo')
      const lastConnectedDevice = wx.getStorageSync('lastConnectedDevice')
      const hasStoredInfo = !!(connectedDeviceInfo && lastConnectedDevice)
      
      // 综合判断连接状态（类似安卓版本的逻辑）
      const isConnected = isBluetoothConnected && (isWxConnected || hasStoredInfo)
      
      // 更新连接状态
      this.onConnectionStateChanged(isConnected)
      
      // 同步更新audioManager的连接状态
      audioManager.setConnected(isConnected)
      
      return isConnected
    } catch (error) {
      console.error('检查连接状态失败:', error)
      this.onConnectionStateChanged(false)
      return false
    }
  },


  // 调试方法：显示当前连接状态信息
  showConnectionDebugInfo() {
    const connectedDeviceInfo = wx.getStorageSync('connectedDeviceInfo')
    const lastConnectedDevice = wx.getStorageSync('lastConnectedDevice')
    const isBluetoothConnected = bluetoothManager.isConnected
    
    const debugInfo = {
      '蓝牙管理器连接状态': isBluetoothConnected,
      '存储的设备信息': !!connectedDeviceInfo,
      '存储的设备ID': !!lastConnectedDevice,
      '设备名称': connectedDeviceInfo?.name || '无',
      '设备ID': lastConnectedDevice || '无',
      '页面连接状态': this.data.deviceConnected
    }
    
    wx.showModal({
      title: '连接状态调试',
      content: Object.entries(debugInfo).map(([key, value]) => `${key}: ${value}`).join('\n'),
      showCancel: false
    })
  },

  // ==================== Vant Slider 事件处理方法 ====================

  // ==================== Vant Slider 设备控制方法 ====================

  // 初始化Vant Slider数据（从设备获取当前值）
  async initVantSliderData() {
    try {
      if (!this.data.deviceConnected) {
        console.log('🎵 [Vant Slider] 设备未连接，使用默认值')
        return
      }
      
      console.log('🎵 [Vant Slider] 初始化滑块数据')
      
      // 这里可以从设备获取当前的音量、低音、高音、平衡值
      // 例如：
      // const volumeResponse = await gaiaManager.getVolume()
      // const bassResponse = await gaiaManager.getBass()
      // const trebleResponse = await gaiaManager.getTreble()
      // const balanceResponse = await gaiaManager.getBalance()
      
      // 暂时使用默认值
      this.setData({
        volumeValue: 0,
        bassValue: 0,
        trebleValue: 0,
        balanceValue: 0
      })
      
    } catch (error) {
      console.error('🎵 [Vant Slider] 初始化滑块数据失败:', error)
    }
  }
})